package Test;

class Animal {
    int age;
    String name;

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
        System.out.println(name + age);
    }

    public void eat() {
        System.out.println(name + "吃饭");
    }

/*
    public Animal sleep() {

    }
*/
}

class Dog extends Animal{
    boolean silly;

    public Dog(int age, String name, boolean silly) {
        super(age, name);
        this.silly = silly;
        System.out.println(silly);
    }

    @Override //检查方法名称是否相同
    public void eat() { //对父类非static，非private，非final修饰，非构造方法的实现过程进行重新编写
        //子类访问权限要大于父类访问权限
        //一定发生在继承层次上
        System.out.println(name + "吃狗粮");
    }
    public void bark() {
        System.out.println("汪汪汪");
    }

/*
    public Dog sleep() {

    }//返回值可以不同，但必须具有父子关系
*/
}

class Cat extends Animal {
    public Cat(int age, String name) {
        super(age, name);
    }
    public void eat() {
        System.out.println(name + "吃猫粮");
    }

    public void CatchMouse() {
        System.out.println(name + "抓老鼠");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog(10, "bitch", true);
        dog.eat(); //调用子类eat方法 子类的访问权限要大于父类的访问权限
    }
}

class Test2 {
    public static void function(int a) {

    }
    public static void function(int a, int b) {

    }
    public static void function() {

    }
    public static void main(String[] args) {
        //静态绑定：编译时，根据传入参数确实定调用的方法
        function();
        function(10);

    }
}

class Test3 {
    public static void main(String[] args) {
        Animal animal = new Cat(10, "bitch");
        if(animal instanceof Cat) {
            Cat cat = (Cat) animal; //向下转型
            cat.CatchMouse();
        }
    }
    public static void function(Animal animal) {
        animal.eat();//此时一个引用调用同一个方法，因为引用指向的对象不同，导致调用该方法的行为不同，这就是多态
    }

    public static void main2(String[] args) {
        Dog dog = new Dog(10, "bitch", true);
        function(dog);//向上转型 方法传参

        Cat cat = new Cat(10, "lovely");
        function(cat);

    }
    public Animal function2() {
        return new Dog(10, "bitch", true); //向上转型
    }
    public static void main1(String[] args) {
        Dog dog = new Dog(10, "bitch", true);
        Animal animal = dog;//向上转型 animal引用指向dog对象 只能调用自己有的属性
        //animal.eat(); 吃狗粮
        //animal.bark(); erro 不能访问 Animal中无bark方法
        //animal.silly = false; erro
        animal.eat();//编译时还是Animal的eat方法，但程序运行时变成了Dog的eat方法，这就是动态绑定

        //直接赋值
        Animal animal2 = new Dog(10, "bitch" ,true);//向上转型 父类接收子类

    }

}
